home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / source / src / basic / _slist.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  2.3 KB  |  130 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  _slist.c
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. #include <LEDA/impl/slist.h>
  17.  
  18. //------------------------------------------------------------------------------
  19. // Members of class SLIST
  20. //------------------------------------------------------------------------------
  21.  
  22. SLIST::SLIST()      
  23. { h=0; 
  24.   t=0;
  25.   count=0;
  26.   iterator=0; 
  27. }
  28.  
  29. SLIST::SLIST(GenPtr a) 
  30. { h=t=new slink(a,0);
  31.   count=1; 
  32.   iterator=0;  
  33. }
  34.  
  35.  
  36. SLIST::SLIST(const SLIST& x)
  37. { register slink* p;
  38.  
  39.   iterator=h=t=0; 
  40.   count = 0; 
  41.                               
  42.   for (p = x.h; p; p = p->succ) append(p->e); 
  43.  
  44.   if (!int_type())
  45.     for (p = h; p; p = p->succ) x.copy_el(p->e);
  46. }
  47.  
  48. GenPtr SLIST::pop()    
  49. { if (iterator!=0) error_handler(1,"pop: deletion while iterator is active");
  50.   GenPtr res;
  51.   if (h) 
  52.   { if (t==h) t = 0;
  53.     slink* x=h; 
  54.     res = x->e;
  55.     h=x->succ; 
  56.     delete x;
  57.     count--;
  58.    }
  59.   return res;
  60. }
  61.  
  62. /*
  63. void SLIST::del_succ(slink* p)    
  64. { slink* q = p->succ;
  65.   if (q) 
  66.   { if (t==q) t = p;
  67.     p->succ = q->succ; 
  68.     delete q;
  69.     count--;
  70.    }
  71. }
  72. */
  73.  
  74.  
  75. slink* SLIST::insert(GenPtr a, slink* p)   
  76. { if (iterator!=0) 
  77.          error_handler(2,"insert: insertion while iterator is active");
  78.   count++;
  79.   p->succ = new slink(a,p->succ); 
  80.   if (t==p) t = p->succ;
  81.   return h;
  82. }
  83.  
  84. void SLIST::conc(SLIST& l)
  85. { if (iterator!=0) error_handler(2,"conc: iterator is active");
  86.  if (count > 0) 
  87.    { t->succ = l.h;
  88.      if (l.count > 0) t = l.t; 
  89.     }
  90.  else 
  91.    { h = l.h; 
  92.      t = l.t; 
  93.     }
  94.  count = count+l.count;
  95.  l.h = l.t = 0;
  96.  l.count = 0;
  97. }
  98.  
  99.  
  100. slink* SLIST::cyclic_succ(slink* loc) const
  101. { if (loc==0) return 0;
  102.   return loc->succ? loc->succ : h;
  103.  }
  104.  
  105. SLIST& SLIST::operator=(const SLIST& x)
  106. { register slink* p;
  107.  
  108.   clear();
  109.  
  110.   for (p = x.h; p; p = p->succ) append(p->e); 
  111.  
  112.   if (!int_type())
  113.     for (p = h; p; p = p->succ) copy_el(p->e);
  114.  
  115.   return *this;
  116.  }
  117.  
  118. void SLIST::clear()
  119. { if (h==0) return;
  120.  
  121.   register slink* p;
  122.  
  123.   if(!int_type())
  124.     for(p = h; p; p = p->succ) clear_el(p->e);
  125.  
  126.   deallocate_list(h,t,sizeof(slink));
  127.   iterator=h=t=0;
  128.   count=0;
  129.  }
  130.